{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "colab": {
   "name": "PI_DeepONet_antideriv",
   "provenance": [],
   "collapsed_sections": []
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  },
  "accelerator": "GPU"
 },
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "id": "mRR_BT5vUnSw"
   },
   "source": [
    "import numpy as onp\n",
    "import jax.numpy as np\n",
    "from jax import random, grad, vmap, jit\n",
    "from jax.example_libraries import optimizers\n",
    "from jax.experimental.ode import odeint\n",
    "from jax.nn import relu\n",
    "from jax.config import config\n",
    "\n",
    "import itertools\n",
    "from functools import partial\n",
    "from torch.utils import data\n",
    "from tqdm import trange\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline"
   ],
   "execution_count": 1,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "rTZSJ2taqCPZ"
   },
   "source": [
    "# Define the neural net\n",
    "def MLP(layers, activation=relu):\n",
    "  ''' Vanilla MLP'''\n",
    "  def init(rng_key):\n",
    "      def init_layer(key, d_in, d_out):\n",
    "          k1, k2 = random.split(key)\n",
    "          glorot_stddev = 1. / np.sqrt((d_in + d_out) / 2.)\n",
    "          W = glorot_stddev * random.normal(k1, (d_in, d_out))\n",
    "          b = np.zeros(d_out)\n",
    "          return W, b\n",
    "      key, *keys = random.split(rng_key, len(layers))\n",
    "      params = list(map(init_layer, keys, layers[:-1], layers[1:]))\n",
    "      return params\n",
    "  def apply(params, inputs):\n",
    "      for W, b in params[:-1]:\n",
    "          outputs = np.dot(inputs, W) + b\n",
    "          inputs = activation(outputs)\n",
    "      W, b = params[-1]\n",
    "      outputs = np.dot(inputs, W) + b\n",
    "      return outputs\n",
    "  return init, apply"
   ],
   "execution_count": 2,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "yPdIBu2xPoi4"
   },
   "source": [
    "# Data generator\n",
    "class DataGenerator(data.Dataset):\n",
    "    def __init__(self, u, y, s, \n",
    "                 batch_size=64, rng_key=random.PRNGKey(1234)):\n",
    "        'Initialization'\n",
    "        self.u = u # input sample\n",
    "        self.y = y # location\n",
    "        self.s = s # labeled data evulated at y (solution measurements, BC/IC conditions, etc.)\n",
    "        \n",
    "        self.N = u.shape[0]\n",
    "        self.batch_size = batch_size\n",
    "        self.key = rng_key\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        'Generate one batch of data'\n",
    "        self.key, subkey = random.split(self.key)\n",
    "        inputs, outputs = self.__data_generation(subkey)\n",
    "        return inputs, outputs\n",
    "\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def __data_generation(self, key):\n",
    "        'Generates data containing batch_size samples'\n",
    "        idx = random.choice(key, self.N, (self.batch_size,), replace=False)\n",
    "        s = self.s[idx,:]\n",
    "        y = self.y[idx,:]\n",
    "        u = self.u[idx,:]\n",
    "        # Construct batch\n",
    "        inputs = (u, y)\n",
    "        outputs = s\n",
    "        return inputs, outputs"
   ],
   "execution_count": 3,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "kbh_Vdc8VmZZ"
   },
   "source": [
    "# Define the model\n",
    "class PI_DeepONet:\n",
    "    def __init__(self, branch_layers, trunk_layers):    \n",
    "        # Network initialization and evaluation functions\n",
    "        self.branch_init, self.branch_apply = MLP(branch_layers, activation=np.tanh)\n",
    "        self.trunk_init, self.trunk_apply = MLP(trunk_layers, activation=np.tanh)\n",
    "\n",
    "        # Initialize\n",
    "        branch_params = self.branch_init(rng_key = random.PRNGKey(1234))\n",
    "        trunk_params = self.trunk_init(rng_key = random.PRNGKey(4321))\n",
    "        params = (branch_params, trunk_params)\n",
    "\n",
    "        # Use optimizers to set optimizer initialization and update functions\n",
    "        self.opt_init, \\\n",
    "        self.opt_update, \\\n",
    "        self.get_params = optimizers.adam(optimizers.exponential_decay(1e-3, \n",
    "                                                                      decay_steps=1000, \n",
    "                                                                      decay_rate=0.9))\n",
    "        self.opt_state = self.opt_init(params)\n",
    "\n",
    "        self.itercount = itertools.count()\n",
    "        \n",
    "        # Loggers\n",
    "        self.loss_log = []\n",
    "        self.loss_operator_log = []\n",
    "        self.loss_physics_log = []\n",
    "\n",
    "    # Define DeepONet architecture\n",
    "    def operator_net(self, params, u, y):\n",
    "        branch_params, trunk_params = params\n",
    "        B = self.branch_apply(branch_params, u)\n",
    "        T = self.trunk_apply(trunk_params, y)\n",
    "        outputs = np.sum(B * T)\n",
    "        return outputs\n",
    "    \n",
    "    # Define ODE/PDE residual\n",
    "    def residual_net(self, params, u, y):\n",
    "        s_y = grad(self.operator_net, argnums = 2)(params, u, y)\n",
    "        return s_y\n",
    "    \n",
    "    # Define operator loss\n",
    "    def loss_operator(self, params, batch):\n",
    "        # Fetch data\n",
    "        # inputs: (u, y), shape = (N, m), (N,1)\n",
    "        # outputs: s, shape = (N,1)\n",
    "        inputs, outputs = batch\n",
    "        u, y = inputs\n",
    "        # Compute forward pass\n",
    "        pred = vmap(self.operator_net, (None, 0, 0))(params, u, y)\n",
    "        # Compute loss\n",
    "        loss = np.mean((outputs.flatten() - pred.flatten())**2)\n",
    "        return loss\n",
    "\n",
    "    # Define physics loss\n",
    "    def loss_physics(self, params, batch):\n",
    "        # Fetch data\n",
    "        # inputs: (u_r, y_r), shape = (NxQ, m), (NxQ,1)\n",
    "        # outputs: s_r, shape = (NxQ, 1)\n",
    "        inputs, outputs = batch\n",
    "        u, y = inputs\n",
    "        # Compute forward pass\n",
    "        pred = vmap(self.residual_net, (None, 0, 0))(params, u, y)\n",
    "        # Compute loss\n",
    "        loss = np.mean((outputs.flatten() - pred.flatten())**2)\n",
    "        return loss    \n",
    "    \n",
    "    # Define total loss\n",
    "    def loss(self, params, operator_batch, physics_batch):\n",
    "        loss_operator = self.loss_operator(params, operator_batch)\n",
    "        loss_physics = self.loss_physics(params, physics_batch)\n",
    "        loss = loss_operator + loss_physics\n",
    "        return loss\n",
    "\n",
    "    # Define a compiled update step\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def step(self, i, opt_state, operator_batch, physics_batch):\n",
    "        params = self.get_params(opt_state)\n",
    "        g = grad(self.loss)(params, operator_batch, physics_batch)\n",
    "        return self.opt_update(i, g, opt_state)\n",
    "\n",
    "    # Optimize parameters in a loop\n",
    "    def train(self, operator_dataset, physics_dataset, nIter = 10000):\n",
    "        # Define the data iterator\n",
    "        operator_data = iter(operator_dataset)\n",
    "        physics_data = iter(physics_dataset)\n",
    "\n",
    "        pbar = trange(nIter)\n",
    "        # Main training loop\n",
    "        for it in pbar:\n",
    "            operator_batch= next(operator_data)\n",
    "            physics_batch = next(physics_data)\n",
    "\n",
    "            self.opt_state = self.step(next(self.itercount), self.opt_state, operator_batch, physics_batch)\n",
    "            \n",
    "            if it % 100 == 0:\n",
    "                params = self.get_params(self.opt_state)\n",
    "\n",
    "                # Compute losses\n",
    "                loss_value = self.loss(params, operator_batch, physics_batch)\n",
    "                loss_operator_value = self.loss_operator(params, operator_batch)\n",
    "                loss_physics_value = self.loss_physics(params, physics_batch)\n",
    "\n",
    "                # Store losses\n",
    "                self.loss_log.append(loss_value)\n",
    "                self.loss_operator_log.append(loss_operator_value)\n",
    "                self.loss_physics_log.append(loss_physics_value)\n",
    "\n",
    "                # Print losses during training\n",
    "                pbar.set_postfix({'Loss': loss_value, \n",
    "                                  'loss_operator' : loss_operator_value, \n",
    "                                  'loss_physics': loss_physics_value})\n",
    "       \n",
    "           \n",
    "    # Evaluates predictions at test points  \n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def predict_s(self, params, U_star, Y_star):\n",
    "        s_pred = vmap(self.operator_net, (None, 0, 0))(params, U_star, Y_star)\n",
    "        return s_pred\n",
    "\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def predict_s_y(self, params, U_star, Y_star):\n",
    "        s_y_pred = vmap(self.residual_net, (None, 0, 0))(params, U_star, Y_star)\n",
    "        return s_y_pred"
   ],
   "execution_count": 4,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "k6NL6NI7P9Jo"
   },
   "source": [
    "# Length scale of a Gaussian random field (GRF)\n",
    "length_scale = 0.2\n",
    "\n",
    "# Define RBF kernel\n",
    "def RBF(x1, x2, params):\n",
    "    output_scale, lengthscales = params\n",
    "    diffs = np.expand_dims(x1 / lengthscales, 1) - \\\n",
    "            np.expand_dims(x2 / lengthscales, 0)\n",
    "    r2 = np.sum(diffs**2, axis=2)\n",
    "    return output_scale * np.exp(-0.5 * r2)\n",
    "\n",
    "# Geneate training data corresponding to one input sample\n",
    "def generate_one_training_data(key, m=100, P=1):\n",
    "    # Sample GP prior at a fine grid\n",
    "    N = 512\n",
    "    gp_params = (1.0, length_scale)\n",
    "    jitter = 1e-10\n",
    "    X = np.linspace(0, 1, N)[:,None]\n",
    "    K = RBF(X, X, gp_params)\n",
    "    L = np.linalg.cholesky(K + jitter*np.eye(N))\n",
    "    gp_sample = np.dot(L, random.normal(key, (N,)))\n",
    "\n",
    "    # Create a callable interpolation function  \n",
    "    u_fn = lambda x, t: np.interp(t, X.flatten(), gp_sample)\n",
    "\n",
    "    # Input sensor locations and measurements\n",
    "    x = np.linspace(0, 1, m)\n",
    "    u = vmap(u_fn, in_axes=(None,0))(0.0, x)\n",
    "\n",
    "    # Output sensor locations and measurements\n",
    "    y_train = random.uniform(key, (P,)).sort() \n",
    "    s_train = odeint(u_fn, 0.0, np.hstack((0.0, y_train)))[1:] # JAX has a bug and always returns s(0), so add a dummy entry to y and return s[1:]\n",
    "\n",
    "    # Tile inputs\n",
    "    u_train = np.tile(u, (P,1))\n",
    "\n",
    "    # training data for the residual\n",
    "    u_r_train = np.tile(u, (m, 1))\n",
    "    y_r_train = x\n",
    "    s_r_train = u\n",
    "\n",
    "    return u_train, y_train, s_train, u_r_train, y_r_train,  s_r_train\n",
    "\n",
    "# Geneate test data corresponding to one input sample\n",
    "def generate_one_test_data(key, m=100, P=100):\n",
    "    # Sample GP prior at a fine grid\n",
    "    N = 512\n",
    "    gp_params = (1.0, length_scale)\n",
    "    jitter = 1e-10\n",
    "    X = np.linspace(0, 1, N)[:,None]\n",
    "    K = RBF(X, X, gp_params)\n",
    "    L = np.linalg.cholesky(K + jitter*np.eye(N))\n",
    "    gp_sample = np.dot(L, random.normal(key, (N,)))\n",
    "\n",
    "    # Create a callable interpolation function  \n",
    "    u_fn = lambda x, t: np.interp(t, X.flatten(), gp_sample)\n",
    "\n",
    "    # Input sensor locations and measurements\n",
    "    x = np.linspace(0, 1, m)\n",
    "    u = vmap(u_fn, in_axes=(None,0))(0.0, x)\n",
    "\n",
    "    # Output sensor locations and measurements\n",
    "    y = np.linspace(0, 1, P)\n",
    "    s = odeint(u_fn, 0.0, y)\n",
    "\n",
    "    # Tile inputs\n",
    "    u = np.tile(u, (P,1))\n",
    "\n",
    "    return u, y, s \n",
    "\n",
    "# Geneate training data corresponding to N input sample\n",
    "def generate_training_data(key, N, m, P):\n",
    "    config.update(\"jax_enable_x64\", True)\n",
    "    keys = random.split(key, N)\n",
    "    gen_fn = jit(lambda key: generate_one_training_data(key, m, P))\n",
    "    u_train, y_train, s_train, u_r_train, y_r_train, s_r_train = vmap(gen_fn)(keys)\n",
    "\n",
    "    u_train = np.float32(u_train.reshape(N * P,-1))\n",
    "    y_train = np.float32(y_train.reshape(N * P,-1))\n",
    "    s_train = np.float32(s_train.reshape(N * P,-1))\n",
    "\n",
    "    u_r_train = np.float32(u_r_train.reshape(N * m,-1))\n",
    "    y_r_train = np.float32(y_r_train.reshape(N * m,-1))\n",
    "    s_r_train = np.float32(s_r_train.reshape(N * m,-1))\n",
    "\n",
    "    config.update(\"jax_enable_x64\", False)\n",
    "    return u_train, y_train, s_train, u_r_train, y_r_train,  s_r_train\n",
    "\n",
    "# Geneate test data corresponding to N input sample\n",
    "def generate_test_data(key, N, m, P):\n",
    "    config.update(\"jax_enable_x64\", True)\n",
    "    keys = random.split(key, N)\n",
    "    gen_fn = jit(lambda key: generate_one_test_data(key, m, P))\n",
    "    u, y, s = vmap(gen_fn)(keys)\n",
    "    u = np.float32(u.reshape(N * P,-1))\n",
    "    y = np.float32(y.reshape(N * P,-1))\n",
    "    s = np.float32(s.reshape(N * P,-1))\n",
    "\n",
    "    config.update(\"jax_enable_x64\", False)\n",
    "    return u, y, s\n",
    "\n",
    "# Compute relative l2 error over N test samples.\n",
    "def compute_error(key, m, P):\n",
    "    # Generate one test sample\n",
    "    u_test, y_test, s_test = generate_test_data(key, 1, m, P)\n",
    "    \n",
    "    # Predict the solution and the residual\n",
    "    s_pred = model.predict_s(params, u_test, y_test)[:,None]\n",
    "    s_y_pred = model.predict_s_y(params, u_test, y_test)\n",
    "\n",
    "    # Compute relative l2 error\n",
    "    error_s = np.linalg.norm(s_test - s_pred) / np.linalg.norm(s_test) \n",
    "    error_u = np.linalg.norm(u_test[::P_test].flatten()[:,None] - s_y_pred) / np.linalg.norm(u_test[::P_test].flatten()[:,None]) \n",
    "\n",
    "    return error_s, error_u"
   ],
   "execution_count": 5,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "ZQ-HVgaQt0DO"
   },
   "source": [
    "N_train = 10000 # number of input samples\n",
    "m = 100 # number of input sensors\n",
    "P_train = 1   # number of output sensors\n",
    "key_train = random.PRNGKey(0) # use different key for generating training data and test data \n",
    "u_train, y_train, s_train, u_r_train, y_r_train, s_r_train = generate_training_data(key_train, N_train, m, P_train)\n",
    "\n",
    "# If solve the foward problem\n",
    "# y_train = np.zeros((N_train, 1))\n",
    "# s_train = np.zeros((N_train, 1))"
   ],
   "execution_count": 6,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "3e0d9ay6he_Q"
   },
   "source": [
    "# Initialize model\n",
    "branch_layers = [m, 50, 50, 50, 50, 50]\n",
    "trunk_layers =  [1, 50, 50, 50, 50, 50]\n",
    "model = PI_DeepONet(branch_layers, trunk_layers)"
   ],
   "execution_count": 7,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "BmduhGwcHHXs"
   },
   "source": [
    "# Create data set\n",
    "batch_size = 10000\n",
    "operator_dataset = DataGenerator(u_train, y_train, s_train, batch_size)\n",
    "physics_dataset = DataGenerator(u_r_train, y_r_train, s_r_train, batch_size)"
   ],
   "execution_count": 8,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "gW8Ej5Jvhf0r",
    "outputId": "edfe4a6b-0774-40d6-dfe2-75dd2edf0cf0"
   },
   "source": [
    "# Train\n",
    "model.train(operator_dataset, physics_dataset, nIter=40000)"
   ],
   "execution_count": 9,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "100%|██████████| 40000/40000 [10:08<00:00, 65.78it/s, Loss=3.1554326e-05, loss_operator=8.4420986e-07, loss_physics=3.0710115e-05]\n"
     ],
     "name": "stderr"
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "hFf9NGzBiDS5",
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "outputId": "4c5d0b89-dbb8-47c9-831c-d8cadbe6d3b5"
   },
   "source": [
    "# Compute test error\n",
    "N_test = 1000 # number of input samples \n",
    "P_test = m   # number of sensors \n",
    "key_test = random.PRNGKey(12345) # A different key \n",
    "keys_test = random.split(key_test, N_test)\n",
    "\n",
    "# Predict\n",
    "params = model.get_params(model.opt_state)\n",
    "\n",
    "# Compute errors over test dataset\n",
    "error_s, error_u = vmap(compute_error, (0, None, None))(keys_test, m, P_test) \n",
    "\n",
    "print('mean of relative L2 error of s: {:.2e}'.format(error_s.mean()))\n",
    "print('mean of relative L2 error of u: {:.2e}'.format(error_u.mean()))\n",
    "\n",
    "print('std of relative L2 error of s: {:.2e}'.format(error_s.std()))\n",
    "print('std L2 error of u: {:.2e}'.format(error_u.std()))"
   ],
   "execution_count": 10,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "mean of relative L2 error of s: 2.49e-03\n",
      "mean of relative L2 error of u: 6.30e-03\n",
      "std of relative L2 error of s: 2.74e-03\n",
      "std L2 error of u: 3.66e-03\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 369
    },
    "id": "uhMrQopGN__b",
    "outputId": "ab6f4564-f56e-4cbe-c87d-a1aabef079c0"
   },
   "source": [
    "#Plot for loss function\n",
    "plt.figure(figsize = (6,5))\n",
    "# plt.plot(model.loss_log, lw=2)\n",
    "plt.plot(model.loss_operator_log, lw=2, label='operator')\n",
    "plt.plot(model.loss_physics_log, lw=2, label='physics')\n",
    "\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Loss')\n",
    "plt.yscale('log')\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ],
   "execution_count": 11,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     }
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "mnzcqRB8F3xo"
   },
   "source": [
    "# Generate test data\n",
    "N_test = 100\n",
    "P_test = m\n",
    "key_test = random.PRNGKey(12345)\n",
    "keys_test = random.split(key_test, N_test)\n",
    "\n",
    "u_test, y_test, s_test =  generate_test_data(key_test, N_test, m, m)\n",
    "\n",
    "params = model.get_params(model.opt_state)\n",
    "\n",
    "# Model predictions\n",
    "s_pred = model.predict_s(params, u_test, y_test)[:,None]\n",
    "s_y_pred = model.predict_s_y(params, u_test, y_test)"
   ],
   "execution_count": 12,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 754
    },
    "id": "NicghBbsmLUH",
    "outputId": "123fd20a-6b1e-49a8-b861-56975710ce18"
   },
   "source": [
    "# Plot for one generated data\n",
    "# idx = onp.random.randint(N_test) # random visualizations\n",
    "idx=0\n",
    "index = np.arange(idx * P_test,(idx + 1) * P_test)\n",
    "\n",
    "# Compute the relative l2 error for one input sample \n",
    "error_u = np.linalg.norm(s_test[index, :] - s_pred[index, :], 2) / np.linalg.norm(s_test[index, :], 2) \n",
    "error_s = np.linalg.norm(u_test[::P_test][idx].flatten()[:,None] - s_y_pred[index, :], 2) / np.linalg.norm(u_test[::P_test][idx].flatten()[:,None], 2) \n",
    "\n",
    "print(\"error_u: {:.3e}\".format(error_u))\n",
    "print(\"error_s: {:.3e}\".format(error_s))\n",
    "\n",
    "# Visualizations\n",
    "# Predicted solution s(y)\n",
    "plt.figure(figsize=(12,5))\n",
    "plt.subplot(1,2,1)\n",
    "plt.plot(y_test[index, :], s_test[index, :], label='Exact s', lw=2)\n",
    "plt.plot(y_test[index, :], s_pred[index, :], '--', label='Predicted s', lw=2)\n",
    "plt.xlabel('y')\n",
    "plt.ylabel('s(y)')\n",
    "plt.tight_layout()\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(1,2,2)\n",
    "plt.plot(y_test[index, :], s_pred[index, :] - s_test[index, :], '--', lw=2, label='error')\n",
    "plt.tight_layout()\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "# Predicted residual u(x)\n",
    "fig = plt.figure(figsize=(12,5))\n",
    "plt.subplot(1,2,1)\n",
    "plt.plot(y_test[index, :], u_test[::P_test][idx], label='Exact u', lw=2)\n",
    "plt.plot(y_test[index, :], s_y_pred[index,:], '--', label='Predicted u', lw=2)\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.subplot(1,2,2)\n",
    "plt.plot(y_test[index, :], s_y_pred[index,:].flatten() - u_test[::P_test][idx] , '--', label='error', lw=2)\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ],
   "execution_count": 13,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "error_u: 2.554e-03\n",
      "error_s: 4.749e-03\n"
     ],
     "name": "stdout"
    },
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     }
    },
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     }
    }
   ]
  }
 ]
}
